package com.etime.shycourse.services.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.etime.shycourse.dao.CourseMapper;
import com.etime.shycourse.dao.CoursetypeMapper;
import com.etime.shycourse.pojo.Course;
import com.etime.shycourse.pojo.Coursetype;
import com.etime.shycourse.services.interfaces.WxCourseServices;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author wb
 * @since 2021-12-17
 */
@Service
public class WxCourseServiceImpl implements WxCourseServices {
    // 课程 dao
    @Autowired
    CourseMapper mapper;
    // 课程类型 dao
    @Autowired
    CoursetypeMapper typeMapper;

    /**
     * 课程
     * 精品推荐 Recommended
     * 查询条件：
     * 是否推荐（courserecommended） = 1
     * 课程状态（coursestate） = 1
     * 课程审核状态（courseaudit） = 1
     * 课程评分（coursescore）>= 9
     * 排序方式条件：按照课程评分（coursescore）降序排列，按照课程排序（coursesort）降序排列。
     * 然后取前5条记录。
     */
    @Override
    public List<Course> selectCourseRecommended() {
        QueryWrapper<Course> wrapper = new QueryWrapper<> ();
        // 是否推荐（courserecommended） = 1 ;  课程状态（coursestate） = 1 ; 课程审核状态（courseaudit） = 1
        wrapper.and (w -> w.eq ("courserecommended", 1).eq ("coursestate", 1).eq ("courseaudit", 1).ge ("coursescore", 9));
        // 排序方式条件：按照课程评分（coursescore）降序排列，按照课程排序（coursesort）降序排列。
        wrapper.orderByDesc ("coursescore", "coursesort");
        // 取前5条记录
        wrapper.last ("limit 5");
        return mapper.selectList (wrapper);
    }

    /**
     * 课程
     * 推荐说明
     * 查询条件：
     * 是否推荐（courserecommended） = 1
     * 课程状态（coursestate） = 1
     * 课程审核状态（courseaudit） = 1
     * 排序方式条件：按照课程排序（coursesort）降序排列。
     * 然后取前10条记录。
     */
    @Override
    public List<Course> selectCourseRecommendation() {
        QueryWrapper<Course> wrapper = new QueryWrapper<> ();
        // 是否推荐（courserecommended） = 1 ;  课程状态（coursestate） = 1 ; 课程审核状态（courseaudit） = 1
        wrapper.and (w -> w.eq ("courserecommended", 1).eq ("coursestate", 1).eq ("courseaudit", 1));
        // 排序方式条件：按照课程排序（coursesort）降序排列。
        wrapper.orderByDesc ("coursesort");
        // 取前5条记录
        wrapper.last ("limit 10");
        return mapper.selectList (wrapper);
    }

    /**
     * 课程类型
     * 初始化显示 课程的分类
     *
     * @return List<Course>
     */
    @Override
    public List<Coursetype> selectCourseTypAll() {
        QueryWrapper<Coursetype> wrapper = new QueryWrapper<> ();
        wrapper.and (w -> {
            //课程类型状态（coursetypestate） = 1 课程类型id（courseptypeid） = -1   课程类型id 大于0
            w.eq ("coursetypestate", 1).eq ("courseptypeid", -1).gt ("coursetypeid", 0);
        });
        return typeMapper.selectList (wrapper);
    }

    /**
     * @param course 课程类型id（coursetypeid） = 左边所选择的分类的id
     *               选择条件 课程大类型 coursetypeid
     *               用户根据课程标题（coursetitle）进行模糊查询
     * @return Page<Course>
     */
    @Override
    public Page<Course> selectCoursePageBy(Course course, Long pagenum, Long pagesize) {
        /**
         * 当前端没有传分页数据时 就使用 page默认的值
         * pagesize = 1L
         * size = 10L;
         * */
        Page<Course> page;
        if (pagenum != null & pagesize != null) {
            page = new Page<> (pagenum, pagesize);
        } else {
            page = new Page<> ();
        }
        QueryWrapper<Course> wrapper = new QueryWrapper<> ();
        // 课程类型id（coursetypeid） = 左边所选择的分类的id
        if (course.getCoursetypeid () != null) {
            //课程列表（复用 用户搜索） 有 课程类型id
            wrapper.and (w -> {
                //课程类型id（coursetypeid） = 左边所选择的分类的id
                w.eq ("coursetypeid", course.getCoursetypeid ())
                        //课程状态（coursestate） = 1
                        .eq ("coursestate", 1)
                        //课程审核状态（courseaudit） = 1
                        .eq ("courseaudit", 1);
            });
        } else {
            // 根据可用状态 课程父类型id=-1 查询出 课程类型是id
            List<Coursetype> courseTypeList = typeMapper.selectList (new QueryWrapper<Coursetype> ().select ("coursetypeid").eq ("coursetypestate", 1).eq ("courseptypeid", -1));
            // courseTypeIdList 可用课程类型id的集合
            ArrayList<Integer> courseTypeIdList = new ArrayList<> ();
            courseTypeList.forEach ((l) -> {
                courseTypeIdList.add (l.getCoursetypeid ());
            });
            // 用户搜索 没有 课程类型id  就只查找课程类型可用状态的
            wrapper.and (w -> {
                // SQL语句中in的个数限制为1000
                w.in ("coursetypeid", courseTypeIdList) // 为了保证课程大的类型可用
                        .eq ("coursestate", 1)
                        .eq ("courseaudit", 1);
            });
        }
        if (course.getCoursetitle () != null) {
            // 用户根据课程标题（coursetitle）进行模糊查询
            wrapper.like ("coursetitle", course.getCoursetitle ());
        }
        //3、排序：按照课程排序（coursesort）降序排列
        wrapper.orderByDesc ("coursesort");
        return mapper.selectPage (page, wrapper);
    }
}
